# search.py
# ---------
# Licensing Information: Please do not distribute or publish solutions to this
# project. You are free to use and extend these projects for educational
# purposes. The Pacman AI projects were developed at UC Berkeley, primarily by
# John DeNero (denero@cs.berkeley.edu) and Dan Klein (klein@cs.berkeley.edu).
# For more info, see http://inst.eecs.berkeley.edu/~cs188/sp09/pacman.html

"""
In search.py, you will implement generic search algorithms which are called 
by Pacman agents (in searchAgents.py).
"""

import util

class SearchProblem:
  """
  This class outlines the structure of a search problem, but doesn't implement
  any of the methods (in object-oriented terminology: an abstract class).
  
  You do not need to change anything in this class, ever.
  """
  
  def getStartState(self):
     """
     Returns the start state for the search problem 
     """
     util.raiseNotDefined()
    
  def isGoalState(self, state):
     """
       state: Search state
    
     Returns True if and only if the state is a valid goal state
     """
     util.raiseNotDefined()

  def getSuccessors(self, state):
     """
       state: Search state
     
     For a given state, this should return a list of triples, 
     (successor, action, stepCost), where 'successor' is a 
     successor to the current state, 'action' is the action
     required to get there, and 'stepCost' is the incremental 
     cost of expanding to that successor
     """
     util.raiseNotDefined()

  def getCostOfActions(self, actions):
     """
      actions: A list of actions to take
 
     This method returns the total cost of a particular sequence of actions.  The sequence must
     be composed of legal moves
     """
     util.raiseNotDefined()
           

def tinyMazeSearch(problem):
  """
  Returns a sequence of moves that solves tinyMaze.  For any other
  maze, the sequence of moves will be incorrect, so only use this for tinyMaze
  """
  from game import Directions
  s = Directions.SOUTH
  w = Directions.WEST
  return  [s,s,w,s,w,w,s,w]

def depthFirstSearch(problem):
  """
  Search the deepest nodes in the search tree first
  [2nd Edition: p 75, 3rd Edition: p 87]
  
  Your search algorithm needs to return a list of actions that reaches
  the goal.  Make sure to implement a graph search algorithm 
  [2nd Edition: Fig. 3.18, 3rd Edition: Fig 3.7].
  
  To get started, you might want to try some of these simple commands to
  understand the search problem that is being passed in:
  
  print "Start:", problem.getStartState()
  print "Is the start a goal?", problem.isGoalState(problem.getStartState())
  print "Start's successors:", problem.getSuccessors(problem.getStartState())
  """
  "*** YOUR CODE HERE ***"
  print "-- SEARCH with DFS --"
  # DFS with stack
  frontier = util.Stack()
  initState = problem.getStartState()
  frontier.push(initState)
  # node pointers 
  parentOf = {}
  actionTo = {}
  pathCostOf = {}
  parentOf[initState] = None
  actionTo[initState] = None
  pathCostOf[initState] = 0
  # explored
  exploredSet = set()
  exploredSet.add(initState)
  # DFS
  while not frontier.isEmpty():
    thisNode = frontier.pop()
    # display
    # print "Now: ", thisNode
    # explored
    if problem.isGoalState(thisNode):
      # solution found
      # traceback
      actionList = []
      u = thisNode
      while parentOf[u]:
        actionList.append(actionTo[u])
        u = parentOf[u]
      actionList.reverse()
      return actionList
    else:
      # expand thisNode
      for successorNode, action, actionCost in problem.getSuccessors(thisNode):
        # avoid redundant paths
        if (successorNode in exploredSet): continue
        exploredSet.add(successorNode)
        # register pointers
        actionTo[successorNode] = action
        parentOf[successorNode] = thisNode
        pathCostOf[successorNode] = pathCostOf[thisNode] + actionCost
        frontier.push(successorNode)
  # no solution found
  print "No solution found!"
  return []



def breadthFirstSearch(problem):
  """
  Search the shallowest nodes in the search tree first.
  [2nd Edition: p 73, 3rd Edition: p 82]
  """
  "*** YOUR CODE HERE ***"
  print "-- SEARCH with BFS --"
  # BFS with queue
  frontier = util.Queue()
  initState = problem.getStartState()
  frontier.push(initState)
  # node pointers 
  parentOf = {}
  actionTo = {}
  pathCostOf = {}
  parentOf[initState] = None
  actionTo[initState] = None
  pathCostOf[initState] = 0
  # explored 
  exploredSet = set()
  exploredSet.add(initState)
  # DFS
  while not frontier.isEmpty():
    thisNode = frontier.pop()
    # display
    print "Now: ", thisNode
    # explored
    if problem.isGoalState(thisNode):
      # solution found
      # traceback
      actionList = []
      u = thisNode
      while parentOf[u]:
        actionList.append(actionTo[u])
        u = parentOf[u]
      actionList.reverse()
      return actionList
    else:
      # expand thisNode
      for successorNode, action, actionCost in problem.getSuccessors(thisNode):
        # avoid redundant paths
        if (successorNode in exploredSet): continue
        exploredSet.add(successorNode)
        # register pointers
        actionTo[successorNode] = action
        parentOf[successorNode] = thisNode
        pathCostOf[successorNode] = pathCostOf[thisNode] + actionCost
        frontier.push(successorNode)
  # no solution found
  print "No solution found!"
  return []
      
def uniformCostSearch(problem):
  "Search the node of least total cost first. "
  "*** YOUR CODE HERE ***"
  print "-- SEARCH with UCS --"
  # UCS with piority queue
  frontier = util.PriorityQueue()
  initState = problem.getStartState()
  ## push with priority = path cost
  frontier.push(initState, 0)
  # node pointers 
  parentOf = {}
  actionTo = {}
  pathCostOf = {}
  parentOf[initState] = None
  actionTo[initState] = None
  pathCostOf[initState] = 0
  # explored 
  exploredSet = set()
  exploredSet.add(initState)
  # DFS
  while not frontier.isEmpty():
    thisNode = frontier.pop()
    # possible redundancy when same state appear more than once in frontier
    # display
    # print "Now: ", thisNode
    if problem.isGoalState(thisNode):
      # solution found
      # traceback
      actionList = []
      u = thisNode
      while parentOf[u]:
        actionList.append(actionTo[u])
        u = parentOf[u]
      actionList.reverse()
      return actionList
    else:
      # expand thisNode
      for successorNode, action, actionCost in problem.getSuccessors(thisNode):
        # avoid redundant paths
        if (successorNode in exploredSet): continue
        exploredSet.add(successorNode)
        # register pointers
        actionTo[successorNode] = action
        parentOf[successorNode] = thisNode
        pathCostOf[successorNode] = pathCostOf[thisNode] + actionCost
        ## push with priority = path cost
        frontier.push(successorNode, pathCostOf[successorNode])
  # no solution found
  print "No solution found!"
  return []

def nullHeuristic(state, problem=None):
  """
  A heuristic function estimates the cost from the current state to the nearest
  goal in the provided SearchProblem.  This heuristic is trivial.
  """
  return 0

def aStarSearch(problem, heuristic=nullHeuristic):
  "Search the node that has the lowest combined cost and heuristic first."
  "*** YOUR CODE HERE ***"
  print "-- SEARCH with A* --"
  # A* with piority queue 
  frontier = util.PriorityQueue()
  initState = problem.getStartState()
  ## push with priority = path cost + heuristic
  frontier.push(initState, 0 + heuristic(initState, problem))
  # node pointers 
  parentOf = {}
  actionTo = {}
  pathCostOf = {}
  parentOf[initState] = None
  actionTo[initState] = None
  pathCostOf[initState] = 0
  # maintain explored
  exploredSet = set()
  exploredSet.add(initState)
  # DFS
  while not frontier.isEmpty():
    thisNode = frontier.pop()
    # display
    # print "Now: ", thisNode
    if problem.isGoalState(thisNode):
      # solution found
      # traceback
      actionList = []
      u = thisNode
      while parentOf[u]:
        actionList.append(actionTo[u])
        u = parentOf[u]
      actionList.reverse()
      return actionList
    else:
      # expand thisNode
      for successorNode, action, actionCost in problem.getSuccessors(thisNode):
        # avoid redundant paths
        if (successorNode in exploredSet): continue
        # mark it as explored before adding to frontier
        # a node is "explored" in the sense that it is/was in frontier
        # !! this is important
        # otherwise, adding the same nodes twice to the frontier may introduce error in those pointer registration
        exploredSet.add(successorNode)
        # register pointers
        actionTo[successorNode] = action
        parentOf[successorNode] = thisNode
        pathCostOf[successorNode] = pathCostOf[thisNode] + actionCost
        ## push with priority = path cost + heuristic
        frontier.push(successorNode, pathCostOf[successorNode] + heuristic(successorNode, problem))
  # no solution found
  print "No solution found!"
  return []
    
  
# Abbreviations
bfs = breadthFirstSearch
dfs = depthFirstSearch
astar = aStarSearch
ucs = uniformCostSearch
